{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "导入一些用到的库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看训练数据集、验证数据集及测试数据集等数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "(55000, 784)\n",
      "(55000,)\n",
      "(5000, 784)\n",
      "(5000,)\n",
      "(10000, 784)\n",
      "(10000,)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./\")\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "images里面有数量不等的图片，每张图片是28x28长度的一个一维向量， 所以用的时候需要先给它还原成28x28的二维图片。labels中则是图片对应的数字的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40d02b5d68>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4,4, idx+1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(mnist.train.labels[idx]))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28,28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义用于训练的网络，首先定义网络的输入。\n",
    "\n",
    "这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个float类型的变量用于设置学习率。\n",
    "为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。\n",
    "\n",
    "模型结构：模型为两层的全链接神经网络。输入为784向量，输出为10维向量，有一个有包括100个神经元的隐层，使用Relu激活函数对第一层输出进行激活作为第二层的输入，第二层为输出层。\n",
    "在之前模型上增加一个隐层，增加节点数到300。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784])\n",
    "y = tf.placeholder(\"int64\", [None])\n",
    "learning_rate = tf.placeholder(\"float\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize(shape, stddev=0.1):\n",
    "  return tf.truncated_normal(shape, stddev=0.1)\n",
    "\n",
    "L1_units_count =300\n",
    "\n",
    "W_1 = tf.Variable(initialize([784, L1_units_count]))\n",
    "b_1 = tf.Variable(initialize([L1_units_count]))\n",
    "logits_1 = tf.matmul(x, W_1) + b_1\n",
    "output_1 = tf.nn.relu(logits_1)\n",
    "\n",
    "\n",
    "L2_units_count = 200 \n",
    "W_2 = tf.Variable(initialize([L1_units_count, L2_units_count]))\n",
    "b_2 = tf.Variable(initialize([L2_units_count]))\n",
    "logits_2 = tf.matmul(output_1, W_2) + b_2  \n",
    "output_2 = tf.nn.relu(logits_2)\n",
    "\n",
    "L3_units_count = 10\n",
    "\n",
    "W_3 = tf.Variable(initialize([L2_units_count,L3_units_count]))\n",
    "b_3 = tf.Variable(initialize([L3_units_count]))\n",
    "logits_3= tf.matmul(output_2, W_3) + b_3\n",
    "\n",
    "\n",
    "logits = logits_3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义loss和用于优化网络的优化器。loss计算使用了sparse_softmax_cross_entropy_with_logits, 这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为可以根据需要设定。\n",
    "\n",
    "对模型训练过程（梯度如何计算，参数如何更新）：采用SGD优化算法，使用交叉熵损失函数，通过比较输出logits和标签y,对参与计算的w进行调整，从输出层开始，向输入层方向逐层计算梯度并更新权重，每次使用32条数据计算梯度，更新权重，训练1000次。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=learning_rate).minimize(cross_entropy_loss)\n",
    "\n",
    "#optimizer=tf.train.AdamOptimizer(lr).minimize(cross_entropy_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "输出的是未经softmax的原始logits，而不是概率分布， 要想看到概率分布，还需要做一下softmax。将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(pred, 1), y)\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "saver用于保存或恢复训练的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "trainig_step = 5000\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "计算图的理解：计算图描述了计算的过程，TensorFlow使用图来表示计算任务。 Tensorflow是一种计算图模型，即用图的形式来表示运算过程的一种模型。Tensorflow程序一般分为图的构建和图的执行两个阶段。构建阶段，也称为图的定义阶段，在构建阶段op的执行步骤被描述成一个图，每次运算的的结果以及原始的输入数据都可称为一个节点（operation ，缩写为op）。在执行阶段，使用会话执行图中的op。\n",
    "\n",
    "以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.411298, the validation accuracy is 0.86\n",
      "after 200 training steps, the loss is 0.18813, the validation accuracy is 0.9342\n",
      "after 300 training steps, the loss is 0.155178, the validation accuracy is 0.953\n",
      "after 400 training steps, the loss is 0.139605, the validation accuracy is 0.9576\n",
      "after 500 training steps, the loss is 0.0510832, the validation accuracy is 0.9624\n",
      "after 600 training steps, the loss is 0.166647, the validation accuracy is 0.964\n",
      "after 700 training steps, the loss is 0.0616979, the validation accuracy is 0.9702\n",
      "after 800 training steps, the loss is 0.0665499, the validation accuracy is 0.9706\n",
      "after 900 training steps, the loss is 0.081151, the validation accuracy is 0.9712\n",
      "after 1000 training steps, the loss is 0.0595996, the validation accuracy is 0.9726\n",
      "after 1100 training steps, the loss is 0.0250781, the validation accuracy is 0.9712\n",
      "after 1200 training steps, the loss is 0.070811, the validation accuracy is 0.976\n",
      "after 1300 training steps, the loss is 0.0486115, the validation accuracy is 0.9714\n",
      "after 1400 training steps, the loss is 0.0289548, the validation accuracy is 0.9764\n",
      "after 1500 training steps, the loss is 0.0174563, the validation accuracy is 0.9758\n",
      "after 1600 training steps, the loss is 0.0934976, the validation accuracy is 0.978\n",
      "after 1700 training steps, the loss is 0.0234337, the validation accuracy is 0.9766\n",
      "after 1800 training steps, the loss is 0.0358822, the validation accuracy is 0.977\n",
      "after 1900 training steps, the loss is 0.0313128, the validation accuracy is 0.978\n",
      "after 2000 training steps, the loss is 0.0173353, the validation accuracy is 0.979\n",
      "after 2100 training steps, the loss is 0.0868308, the validation accuracy is 0.9772\n",
      "after 2200 training steps, the loss is 0.0278003, the validation accuracy is 0.979\n",
      "after 2300 training steps, the loss is 0.0966668, the validation accuracy is 0.9784\n",
      "after 2400 training steps, the loss is 0.0218055, the validation accuracy is 0.9778\n",
      "after 2500 training steps, the loss is 0.0162058, the validation accuracy is 0.9792\n",
      "after 2600 training steps, the loss is 0.0165442, the validation accuracy is 0.9832\n",
      "after 2700 training steps, the loss is 0.0332794, the validation accuracy is 0.981\n",
      "after 2800 training steps, the loss is 0.050479, the validation accuracy is 0.984\n",
      "after 2900 training steps, the loss is 0.0178068, the validation accuracy is 0.9814\n",
      "after 3000 training steps, the loss is 0.0181868, the validation accuracy is 0.9812\n",
      "after 3100 training steps, the loss is 0.0327069, the validation accuracy is 0.982\n",
      "after 3200 training steps, the loss is 0.0122712, the validation accuracy is 0.983\n",
      "after 3300 training steps, the loss is 0.0214768, the validation accuracy is 0.9816\n",
      "after 3400 training steps, the loss is 0.02122, the validation accuracy is 0.9826\n",
      "after 3500 training steps, the loss is 0.0272331, the validation accuracy is 0.9834\n",
      "after 3600 training steps, the loss is 0.0196857, the validation accuracy is 0.9834\n",
      "after 3700 training steps, the loss is 0.00376835, the validation accuracy is 0.9828\n",
      "after 3800 training steps, the loss is 0.0281314, the validation accuracy is 0.9824\n",
      "after 3900 training steps, the loss is 0.0130035, the validation accuracy is 0.9834\n",
      "after 4000 training steps, the loss is 0.00623371, the validation accuracy is 0.9832\n",
      "after 4100 training steps, the loss is 0.0106589, the validation accuracy is 0.9834\n",
      "after 4200 training steps, the loss is 0.0227788, the validation accuracy is 0.9818\n",
      "after 4300 training steps, the loss is 0.0090258, the validation accuracy is 0.9834\n",
      "after 4400 training steps, the loss is 0.00603098, the validation accuracy is 0.9834\n",
      "after 4500 training steps, the loss is 0.00444402, the validation accuracy is 0.9836\n",
      "after 4600 training steps, the loss is 0.0052809, the validation accuracy is 0.9832\n",
      "after 4700 training steps, the loss is 0.0142453, the validation accuracy is 0.9822\n",
      "after 4800 training steps, the loss is 0.0036426, the validation accuracy is 0.9842\n",
      "after 4900 training steps, the loss is 0.00199931, the validation accuracy is 0.9842\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9812\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels}\n",
    "    \n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        if  i>1000:\n",
    "            lr = 0.3\n",
    "        if  i>2000:\n",
    "            lr = 0.1\n",
    "        _, loss = sess.run(\n",
    "            [optimizer, cross_entropy_loss],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                learning_rate: 0.3\n",
    "            })\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用训练的模型做测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-4900\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f40c03e3ac8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16]\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(mnist.test.labels[idx],\n",
    "                                                  order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "本节代码及如何在模型中添加L1/L2正则化,使⽤不同的初始化⽅式不会，请老师在课上详细讲解，谢谢。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
